// 1.在执行完new,生成实例后
var hook = {
  args: [
    "name",
    "age",
  ],
  taps: [
  ],
  call: function (...args) {
    this.call = this._createCall('sync');//调用它的时候 ，它会动态创建call函数，重写this.call属性
    return this.call(...args);//执行新创建的call方法，
  },
  callAsync: function (...args) {
    this.callAsync = this._createCall('async');//调用它的时候 ，它会动态创建callAsync函数，重写this.callAsync属性
    return this.callAsync(...args);//执行新创建的call方法，
  },
  promise: function (...args) {
    this.promise = this._createCall('promise');//调用它的时候 ，它会动态创建callAsync函数，重写this.callAsync属性
    return this.promise(...args);//执行新创建的call方法，
  },
  interceptors: [
  ],
}
// 2.执行实例hook上的原型方法intercept，生成新的hook.interceptors
hook = {
  args: [
    "name",
    "age",
  ],
  taps: [
  ],
  call: function (...args) {
    this.call = this._createCall('sync');//调用它的时候 ，它会动态创建call函数，重写this.call属性
    return this.call(...args);//执行新创建的call方法，
  },
  callAsync: function (...args) {
    this.callAsync = this._createCall('async');//调用它的时候 ，它会动态创建callAsync函数，重写this.callAsync属性
    return this.callAsync(...args);//执行新创建的call方法，
  },
  promise: function (...args) {
    this.promise = this._createCall('promise');//调用它的时候 ，它会动态创建callAsync函数，重写this.callAsync属性
    return this.promise(...args);//执行新创建的call方法，
  },
  interceptors: [
    {
      register: function(tapInfo){//每当订阅一个新的事件函数就会触发
        console.log(`拦截器1 register`,tapInfo.name);
        return tapInfo;
      },
      tap: function(tapInfo){//每当一个事件函数执行了就会触发
        console.log(`拦截器1 tap`,tapInfo.name);
      },
      call: function(name,age){//每次调用call会触发一次
        console.log(`拦截器1 call`,name,age);
      },
    },
    {
      register: function(tapInfo){
        console.log(`拦截器2 register`,tapInfo.name);
        return tapInfo;
      },
      tap: function(tapInfo){
        console.log(`拦截器2 tap`,tapInfo.name);
      },
      call: function(name,age){
        console.log(`拦截器2 call`,name,age);
      },
    },
  ],
}
// 3.执行hook.tap过程中，如hook.interceptors数组中有值，那么会把遍历执行数组中的register方法，传入的参数是tapInfo,最后返回新的tapInfo,继续执行剩下的过程生成新的hooks实例
tapInfo = {
  name: "事件函数A",
  type: "sync",
  fn: (name,age)=>{
    console.log('事件函数A',name,age);
  },
}
function _runRegisterInterceptors(tapInfo){
  for(const interceptor of this.interceptors){
      if(interceptor.register){//如果它身上有注册拦截器的话
        let newTapInfo = interceptor.register(tapInfo);
        if(newTapInfo)//如果注册拦截器返回了新的tapInfo,就用新的替换老的
           tapInfo=newTapInfo;
      }
  }
  return tapInfo 
}
hook = {
  args: [
    "name",
    "age",
  ],
  taps: [
    {
      name: "事件函数A",
      type: "sync",
      fn: (name,age)=>{
        console.log('事件函数A',name,age);
      },
    },
  ],
  call: function (...args) {
    this.call = this._createCall('sync');//调用它的时候 ，它会动态创建call函数，重写this.call属性
    return this.call(...args);//执行新创建的call方法，
  },
  callAsync: function (...args) {
    this.callAsync = this._createCall('async');//调用它的时候 ，它会动态创建callAsync函数，重写this.callAsync属性
    return this.callAsync(...args);//执行新创建的call方法，
  },
  promise: function (...args) {
    this.promise = this._createCall('promise');//调用它的时候 ，它会动态创建callAsync函数，重写this.callAsync属性
    return this.promise(...args);//执行新创建的call方法，
  },
  interceptors: [
    {
      register: function(tapInfo){//每当订阅一个新的事件函数就会触发
        console.log(`拦截器1 register`,tapInfo.name);
        return tapInfo;
      },
      tap: function(tapInfo){//每当一个事件函数执行了就会触发
        console.log(`拦截器1 tap`,tapInfo.name);
      },
      call: function(name,age){//每次调用call会触发一次
        console.log(`拦截器1 call`,name,age);
      },
    },
    {
      register: function(tapInfo){
        console.log(`拦截器2 register`,tapInfo.name);
        return tapInfo;
      },
      tap: function(tapInfo){
        console.log(`拦截器2 tap`,tapInfo.name);
      },
      call: function(name,age){
        console.log(`拦截器2 call`,name,age);
      },
    },
  ],
}

// 4.执行hook.call生成的hook实例为
hook = {
  args: [
    "name",
    "age",
  ],
  taps: [
    {
      name: "事件函数A",
      type: "sync",
      fn: (name,age)=>{
        console.log('事件函数A',name,age);
      },
    },
  ],
  call: function (...args) {
    this.call = this._createCall('sync');//调用它的时候 ，它会动态创建call函数，重写this.call属性
    return this.call(...args);//执行新创建的call方法，
  },
  callAsync: function (...args) {
    this.callAsync = this._createCall('async');//调用它的时候 ，它会动态创建callAsync函数，重写this.callAsync属性
    return this.callAsync(...args);//执行新创建的call方法，
  },
  promise: function (...args) {
    this.promise = this._createCall('promise');//调用它的时候 ，它会动态创建callAsync函数，重写this.callAsync属性
    return this.promise(...args);//执行新创建的call方法，
  },
  interceptors: [
    {
      register: function(tapInfo){//每当订阅一个新的事件函数就会触发
        console.log(`拦截器1 register`,tapInfo.name);
        return tapInfo;
      },
      tap: function(tapInfo){//每当一个事件函数执行了就会触发
        console.log(`拦截器1 tap`,tapInfo.name);
      },
      call: function(name,age){//每次调用call会触发一次
        console.log(`拦截器1 call`,name,age);
      },
    },
    {
      register: function(tapInfo){
        console.log(`拦截器2 register`,tapInfo.name);
        return tapInfo;
      },
      tap: function(tapInfo){
        console.log(`拦截器2 tap`,tapInfo.name);
      },
      call: function(name,age){
        console.log(`拦截器2 call`,name,age);
      },
    },
  ],
  _x: [
    (name,age)=>{
      console.log('事件函数A',name,age);
    },
  ],
}
// 5.执行factory.create传入的参数options为
options = {
  taps: [
    {
      name: "事件函数A",
      type: "sync",
      fn: (name,age)=>{
        console.log('事件函数A',name,age);
      },
    },
  ],
  args: [
    "name",
    "age",
  ],
  interceptors: [
    {
      register: function(tapInfo){//每当订阅一个新的事件函数就会触发
        console.log(`拦截器1 register`,tapInfo.name);
        return tapInfo;
      },
      tap: function(tapInfo){//每当一个事件函数执行了就会触发
        console.log(`拦截器1 tap`,tapInfo.name);
      },
      call: function(name,age){//每次调用call会触发一次
        console.log(`拦截器1 call`,name,age);
      },
    },
    {
      register: function(tapInfo){
        console.log(`拦截器2 register`,tapInfo.name);
        return tapInfo;
      },
      tap: function(tapInfo){
        console.log(`拦截器2 tap`,tapInfo.name);
      },
      call: function(name,age){
        console.log(`拦截器2 call`,name,age);
      },
    },
  ],
  type: "sync",
}
// 6.生成函数，并且传入参数(...args)执行
(function anonymous(name, age) {
  var _x = this._x;
  var _taps = this.taps;
  var _interceptors = this.interceptors;
  _interceptors[0].call(name, age);
  _interceptors[1].call(name, age);
  
  var _tap0 = _taps[0];
  _interceptors[0].tap(_tap0);
  _interceptors[1].tap(_tap0);
  var _fn0 = _x[0];
  _fn0(name, age);

})(...args)